Sky at Night 2007 June/SAN CD 6-2007 CD-ROM 25.iso/pc/Software/AstroGrav_Win/Java/jre1.6.0/lib/rt.jar/javax/swing/JTable.class

Java Class File | 2006-11-29 | 43.5 KB | 2,622 lines

package javax.swing;

import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.KeyboardFocusManager;
import java.awt.LayoutManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.print.Printable;
import java.awt.print.PrinterAbortException;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.text.MessageFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.EventObject;
import java.util.Hashtable;
import java.util.Vector;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.print.PrintService;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.swing.JTable.7;
import javax.swing.border.Border;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.RowSorterEvent;
import javax.swing.event.RowSorterListener;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableColumnModelListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.event.RowSorterEvent.Type;
import javax.swing.plaf.TableUI;
import javax.swing.plaf.UIResource;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;
import sun.swing.PrintingStatus;
import sun.swing.SwingUtilities2;
import sun.swing.SwingUtilities2.Section;

public class JTable extends JComponent implements TableModelListener, Scrollable, TableColumnModelListener, ListSelectionListener, CellEditorListener, Accessible, RowSorterListener {
   private static final String uiClassID = "TableUI";
   public static final int AUTO_RESIZE_OFF = 0;
   public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
   public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
   public static final int AUTO_RESIZE_LAST_COLUMN = 3;
   public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
   protected TableModel dataModel;
   protected TableColumnModel columnModel;
   protected ListSelectionModel selectionModel;
   protected JTableHeader tableHeader;
   protected int rowHeight;
   protected int rowMargin;
   protected Color gridColor;
   protected boolean showHorizontalLines;
   protected boolean showVerticalLines;
   protected int autoResizeMode;
   protected boolean autoCreateColumnsFromModel;
   protected Dimension preferredViewportSize;
   protected boolean rowSelectionAllowed;
   protected boolean cellSelectionEnabled;
   protected transient Component editorComp;
   protected transient TableCellEditor cellEditor;
   protected transient int editingColumn;
   protected transient int editingRow;
   protected transient Hashtable defaultRenderersByColumnClass;
   protected transient Hashtable defaultEditorsByColumnClass;
   protected Color selectionForeground;
   protected Color selectionBackground;
   private SizeSequence rowModel;
   private boolean dragEnabled;
   private boolean surrendersFocusOnKeystroke;
   private PropertyChangeListener editorRemover;
   private boolean columnSelectionAdjusting;
   private boolean rowSelectionAdjusting;
   private Throwable printError;
   private boolean isRowHeightSet;
   private boolean updateSelectionOnSort;
   private transient SortManager sortManager;
   private boolean ignoreSortChange;
   private boolean sorterChanged;
   private boolean autoCreateRowSorter;
   private boolean fillsViewportHeight;
   private DropMode dropMode;
   private transient DropLocation dropLocation;

   public JTable() {
      this((TableModel)null, (TableColumnModel)null, (ListSelectionModel)null);
   }

   public JTable(TableModel var1) {
      this(var1, (TableColumnModel)null, (ListSelectionModel)null);
   }

   public JTable(TableModel var1, TableColumnModel var2) {
      this(var1, var2, (ListSelectionModel)null);
   }

   public JTable(TableModel var1, TableColumnModel var2, ListSelectionModel var3) {
      this.editorRemover = null;
      this.dropMode = DropMode.USE_SELECTION;
      this.setLayout((LayoutManager)null);
      this.setFocusTraversalKeys(0, JComponent.getManagingFocusForwardTraversalKeys());
      this.setFocusTraversalKeys(1, JComponent.getManagingFocusBackwardTraversalKeys());
      if (var2 == null) {
         var2 = this.createDefaultColumnModel();
         this.autoCreateColumnsFromModel = true;
      }

      this.setColumnModel(var2);
      if (var3 == null) {
         var3 = this.createDefaultSelectionModel();
      }

      this.setSelectionModel(var3);
      if (var1 == null) {
         var1 = this.createDefaultDataModel();
      }

      this.setModel(var1);
      this.initializeLocalVars();
      this.updateUI();
   }

   public JTable(int var1, int var2) {
      this(new DefaultTableModel(var1, var2));
   }

   public JTable(Vector var1, Vector var2) {
      this(new DefaultTableModel(var1, var2));
   }

   public JTable(Object[][] var1, Object[] var2) {
      this(new 1(var2, var1));
   }

   public void addNotify() {
      super.addNotify();
      this.configureEnclosingScrollPane();
   }

   protected void configureEnclosingScrollPane() {
      Container var1 = this.getParent();
      if (var1 instanceof JViewport) {
         Container var2 = var1.getParent();
         if (var2 instanceof JScrollPane) {
            JScrollPane var3 = (JScrollPane)var2;
            JViewport var4 = var3.getViewport();
            if (var4 == null || var4.getView() != this) {
               return;
            }

            var3.setColumnHeaderView(this.getTableHeader());
            Border var5 = var3.getBorder();
            if (var5 == null || var5 instanceof UIResource) {
               Border var6 = UIManager.getBorder("Table.scrollPaneBorder");
               if (var6 != null) {
                  var3.setBorder(var6);
               }
            }
         }
      }

   }

   public void removeNotify() {
      KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener("permanentFocusOwner", this.editorRemover);
      this.editorRemover = null;
      this.unconfigureEnclosingScrollPane();
      super.removeNotify();
   }

   protected void unconfigureEnclosingScrollPane() {
      Container var1 = this.getParent();
      if (var1 instanceof JViewport) {
         Container var2 = var1.getParent();
         if (var2 instanceof JScrollPane) {
            JScrollPane var3 = (JScrollPane)var2;
            JViewport var4 = var3.getViewport();
            if (var4 == null || var4.getView() != this) {
               return;
            }

            var3.setColumnHeaderView((Component)null);
         }
      }

   }

   void setUIProperty(String var1, Object var2) {
      if (var1 == "rowHeight") {
         if (!this.isRowHeightSet) {
            this.setRowHeight(((Number)var2).intValue());
            this.isRowHeightSet = false;
         }

      } else {
         super.setUIProperty(var1, var2);
      }
   }

   /** @deprecated */
   @Deprecated
   public static JScrollPane createScrollPaneForTable(JTable var0) {
      return new JScrollPane(var0);
   }

   public void setTableHeader(JTableHeader var1) {
      if (this.tableHeader != var1) {
         JTableHeader var2 = this.tableHeader;
         if (var2 != null) {
            var2.setTable((JTable)null);
         }

         this.tableHeader = var1;
         if (var1 != null) {
            var1.setTable(this);
         }

         this.firePropertyChange("tableHeader", var2, var1);
      }

   }

   public JTableHeader getTableHeader() {
      return this.tableHeader;
   }

   public void setRowHeight(int var1) {
      if (var1 <= 0) {
         throw new IllegalArgumentException("New row height less than 1");
      } else {
         int var2 = this.rowHeight;
         this.rowHeight = var1;
         this.rowModel = null;
         if (this.sortManager != null) {
            javax.swing.JTable.SortManager.access$002(this.sortManager, (SizeSequence)null);
         }

         this.isRowHeightSet = true;
         this.resizeAndRepaint();
         this.firePropertyChange("rowHeight", var2, var1);
      }
   }

   public int getRowHeight() {
      return this.rowHeight;
   }

   private SizeSequence getRowModel() {
      if (this.rowModel == null) {
         this.rowModel = new SizeSequence(this.getRowCount(), this.getRowHeight());
      }

      return this.rowModel;
   }

   public void setRowHeight(int var1, int var2) {
      if (var2 <= 0) {
         throw new IllegalArgumentException("New row height less than 1");
      } else {
         this.getRowModel().setSize(var1, var2);
         if (this.sortManager != null) {
            this.sortManager.setViewRowHeight(var1, var2);
         }

         this.resizeAndRepaint();
      }
   }

   public int getRowHeight(int var1) {
      return this.rowModel == null ? this.getRowHeight() : this.rowModel.getSize(var1);
   }

   public void setRowMargin(int var1) {
      int var2 = this.rowMargin;
      this.rowMargin = var1;
      this.resizeAndRepaint();
      this.firePropertyChange("rowMargin", var2, var1);
   }

   public int getRowMargin() {
      return this.rowMargin;
   }

   public void setIntercellSpacing(Dimension var1) {
      this.setRowMargin(var1.height);
      this.getColumnModel().setColumnMargin(var1.width);
      this.resizeAndRepaint();
   }

   public Dimension getIntercellSpacing() {
      return new Dimension(this.getColumnModel().getColumnMargin(), this.rowMargin);
   }

   public void setGridColor(Color var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("New color is null");
      } else {
         Color var2 = this.gridColor;
         this.gridColor = var1;
         this.firePropertyChange("gridColor", var2, var1);
         this.repaint();
      }
   }

   public Color getGridColor() {
      return this.gridColor;
   }

   public void setShowGrid(boolean var1) {
      this.setShowHorizontalLines(var1);
      this.setShowVerticalLines(var1);
      this.repaint();
   }

   public void setShowHorizontalLines(boolean var1) {
      boolean var2 = this.showHorizontalLines;
      this.showHorizontalLines = var1;
      this.firePropertyChange("showHorizontalLines", var2, var1);
      this.repaint();
   }

   public void setShowVerticalLines(boolean var1) {
      boolean var2 = this.showVerticalLines;
      this.showVerticalLines = var1;
      this.firePropertyChange("showVerticalLines", var2, var1);
      this.repaint();
   }

   public boolean getShowHorizontalLines() {
      return this.showHorizontalLines;
   }

   public boolean getShowVerticalLines() {
      return this.showVerticalLines;
   }

   public void setAutoResizeMode(int var1) {
      if (var1 == 0 || var1 == 1 || var1 == 2 || var1 == 3 || var1 == 4) {
         int var2 = this.autoResizeMode;
         this.autoResizeMode = var1;
         this.resizeAndRepaint();
         if (this.tableHeader != null) {
            this.tableHeader.resizeAndRepaint();
         }

         this.firePropertyChange("autoResizeMode", var2, this.autoResizeMode);
      }

   }

   public int getAutoResizeMode() {
      return this.autoResizeMode;
   }

   public void setAutoCreateColumnsFromModel(boolean var1) {
      if (this.autoCreateColumnsFromModel != var1) {
         boolean var2 = this.autoCreateColumnsFromModel;
         this.autoCreateColumnsFromModel = var1;
         if (var1) {
            this.createDefaultColumnsFromModel();
         }

         this.firePropertyChange("autoCreateColumnsFromModel", var2, var1);
      }

   }

   public boolean getAutoCreateColumnsFromModel() {
      return this.autoCreateColumnsFromModel;
   }

   public void createDefaultColumnsFromModel() {
      TableModel var1 = this.getModel();
      if (var1 != null) {
         TableColumnModel var2 = this.getColumnModel();

         while(var2.getColumnCount() > 0) {
            var2.removeColumn(var2.getColumn(0));
         }

         for(int var3 = 0; var3 < var1.getColumnCount(); ++var3) {
            TableColumn var4 = new TableColumn(var3);
            this.addColumn(var4);
         }
      }

   }

   public void setDefaultRenderer(Class<?> var1, TableCellRenderer var2) {
      if (var2 != null) {
         this.defaultRenderersByColumnClass.put(var1, var2);
      } else {
         this.defaultRenderersByColumnClass.remove(var1);
      }

   }

   public TableCellRenderer getDefaultRenderer(Class<?> var1) {
      if (var1 == null) {
         return null;
      } else {
         Object var2 = this.defaultRenderersByColumnClass.get(var1);
         return var2 != null ? (TableCellRenderer)var2 : this.getDefaultRenderer(var1.getSuperclass());
      }
   }

   public void setDefaultEditor(Class<?> var1, TableCellEditor var2) {
      if (var2 != null) {
         this.defaultEditorsByColumnClass.put(var1, var2);
      } else {
         this.defaultEditorsByColumnClass.remove(var1);
      }

   }

   public TableCellEditor getDefaultEditor(Class<?> var1) {
      if (var1 == null) {
         return null;
      } else {
         Object var2 = this.defaultEditorsByColumnClass.get(var1);
         return var2 != null ? (TableCellEditor)var2 : this.getDefaultEditor(var1.getSuperclass());
      }
   }

   public void setDragEnabled(boolean var1) {
      if (var1 && GraphicsEnvironment.isHeadless()) {
         throw new HeadlessException();
      } else {
         this.dragEnabled = var1;
      }
   }

   public boolean getDragEnabled() {
      return this.dragEnabled;
   }

   public final void setDropMode(DropMode var1) {
      if (var1 != null) {
         switch (7.$SwitchMap$javax$swing$DropMode[var1.ordinal()]) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
               this.dropMode = var1;
               return;
         }
      }

      throw new IllegalArgumentException(var1 + ": Unsupported drop mode for table");
   }

   public final DropMode getDropMode() {
      return this.dropMode;
   }

   DropLocation dropLocationForPoint(Point var1) {
      DropLocation var2 = null;
      int var3 = this.rowAtPoint(var1);
      int var4 = this.columnAtPoint(var1);
      boolean var5 = Boolean.TRUE == this.getClientProperty("Table.isFileList") && SwingUtilities2.pointOutsidePrefSize(this, var3, var4, var1);
      Rectangle var6 = this.getCellRect(var3, var4, true);
      boolean var9 = false;
      boolean var10 = this.getComponentOrientation().isLeftToRight();
      switch (7.$SwitchMap$javax$swing$DropMode[this.dropMode.ordinal()]) {
         case 1:
         case 2:
            if (var3 != -1 && var4 != -1 && !var5) {
               var2 = new DropLocation(var1, var3, var4, false, false, (1)null);
            } else {
               var2 = new DropLocation(var1, -1, -1, false, false, (1)null);
            }
            break;
         case 3:
            if (var3 == -1 && var4 == -1) {
               var2 = new DropLocation(var1, 0, 0, true, true, (1)null);
            } else {
               SwingUtilities2.Section var12 = SwingUtilities2.liesInHorizontal(var6, var1, var10, true);
               if (var3 == -1) {
                  if (var12 == Section.LEADING) {
                     var2 = new DropLocation(var1, this.getRowCount(), var4, true, true, (1)null);
                  } else if (var12 == Section.TRAILING) {
                     var2 = new DropLocation(var1, this.getRowCount(), var4 + 1, true, true, (1)null);
                  } else {
                     var2 = new DropLocation(var1, this.getRowCount(), var4, true, false, (1)null);
                  }
               } else if (var12 != Section.LEADING && var12 != Section.TRAILING) {
                  if (SwingUtilities2.liesInVertical(var6, var1, false) == Section.TRAILING) {
                     ++var3;
                  }

                  var2 = new DropLocation(var1, var3, var4, true, false, (1)null);
               } else {
                  SwingUtilities2.Section var14 = SwingUtilities2.liesInVertical(var6, var1, true);
                  if (var14 == Section.LEADING) {
                     var9 = true;
                  } else if (var14 == Section.TRAILING) {
                     ++var3;
                     var9 = true;
                  }

                  var2 = new DropLocation(var1, var3, var12 == Section.TRAILING ? var4 + 1 : var4, var9, true, (1)null);
               }
            }
            break;
         case 4:
            if (var3 == -1 && var4 == -1) {
               var2 = new DropLocation(var1, -1, -1, false, false, (1)null);
            } else if (var3 == -1) {
               var2 = new DropLocation(var1, this.getRowCount(), var4, true, false, (1)null);
            } else {
               if (SwingUtilities2.liesInVertical(var6, var1, false) == Section.TRAILING) {
                  ++var3;
               }

               var2 = new DropLocation(var1, var3, var4, true, false, (1)null);
            }
            break;
         case 5:
            if (var3 == -1) {
               var2 = new DropLocation(var1, -1, -1, false, false, (1)null);
            } else if (var4 == -1) {
               var2 = new DropLocation(var1, this.getColumnCount(), var4, false, true, (1)null);
            } else {
               if (SwingUtilities2.liesInHorizontal(var6, var1, var10, false) == Section.TRAILING) {
                  ++var4;
               }

               var2 = new DropLocation(var1, var3, var4, false, true, (1)null);
            }
            break;
         case 6:
            if (var3 == -1 && var4 == -1) {
               var2 = new DropLocation(var1, 0, 0, true, true, (1)null);
            } else {
               SwingUtilities2.Section var11 = SwingUtilities2.liesInHorizontal(var6, var1, var10, true);
               if (var3 == -1) {
                  if (var11 == Section.LEADING) {
                     var2 = new DropLocation(var1, this.getRowCount(), var4, true, true, (1)null);
                  } else if (var11 == Section.TRAILING) {
                     var2 = new DropLocation(var1, this.getRowCount(), var4 + 1, true, true, (1)null);
                  } else {
                     var2 = new DropLocation(var1, this.getRowCount(), var4, true, false, (1)null);
                  }
               } else {
                  SwingUtilities2.Section var13 = SwingUtilities2.liesInVertical(var6, var1, true);
                  if (var13 == Section.LEADING) {
                     var9 = true;
                  } else if (var13 == Section.TRAILING) {
                     ++var3;
                     var9 = true;
                  }

                  var2 = new DropLocation(var1, var3, var11 == Section.TRAILING ? var4 + 1 : var4, var9, var11 != Section.MIDDLE, (1)null);
               }
            }
            break;
         case 7:
            if (var3 == -1 && var4 == -1) {
               var2 = new DropLocation(var1, -1, -1, false, false, (1)null);
            } else if (var3 == -1) {
               var2 = new DropLocation(var1, this.getRowCount(), var4, true, false, (1)null);
            } else {
               SwingUtilities2.Section var8 = SwingUtilities2.liesInVertical(var6, var1, true);
               if (var8 == Section.LEADING) {
                  var9 = true;
               } else if (var8 == Section.TRAILING) {
                  ++var3;
                  var9 = true;
               }

               var2 = new DropLocation(var1, var3, var4, var9, false, (1)null);
            }
            break;
         case 8:
            if (var3 == -1) {
               var2 = new DropLocation(var1, -1, -1, false, false, (1)null);
            } else if (var4 == -1) {
               var2 = new DropLocation(var1, var3, this.getColumnCount(), false, true, (1)null);
            } else {
               SwingUtilities2.Section var7 = SwingUtilities2.liesInHorizontal(var6, var1, var10, true);
               if (var7 == Section.LEADING) {
                  var9 = true;
               } else if (var7 == Section.TRAILING) {
                  ++var4;
                  var9 = true;
               }

               var2 = new DropLocation(var1, var3, var4, false, var9, (1)null);
            }
            break;
         default:
            assert false : "Unexpected drop mode";
      }

      return var2;
   }

   Object setDropLocation(TransferHandler.DropLocation var1, Object var2, boolean var3) {
      Object var4 = null;
      DropLocation var5 = (DropLocation)var1;
      if (this.dropMode == DropMode.USE_SELECTION) {
         if (var5 == null) {
            if (!var3 && var2 != null) {
               this.clearSelection();
               int[] var6 = ((int[][])((int[][])var2))[0];
               int[] var7 = ((int[][])((int[][])var2))[1];
               int[] var8 = ((int[][])((int[][])var2))[2];

               for(int var9 = 0; var9 < var6.length; ++var9) {
                  this.addRowSelectionInterval(var6[var9], var6[var9]);
               }

               for(int var11 = 0; var11 < var7.length; ++var11) {
                  this.addColumnSelectionInterval(var7[var11], var7[var11]);
               }

               SwingUtilities2.setLeadAnchorWithoutSelection(this.getSelectionModel(), var8[1], var8[0]);
               SwingUtilities2.setLeadAnchorWithoutSelection(this.getColumnModel().getSelectionModel(), var8[3], var8[2]);
            }
         } else {
            if (this.dropLocation == null) {
               var4 = new int[][]{this.getSelectedRows(), this.getSelectedColumns(), {this.getAdjustedIndex(this.getSelectionModel().getAnchorSelectionIndex(), true), this.getAdjustedIndex(this.getSelectionModel().getLeadSelectionIndex(), true), this.getAdjustedIndex(this.getColumnModel().getSelectionModel().getAnchorSelectionIndex(), false), this.getAdjustedIndex(this.getColumnModel().getSelectionModel().getLeadSelectionIndex(), false)}};
            } else {
               var4 = var2;
            }

            if (var5.getRow() == -1) {
               this.clearSelectionAndLeadAnchor();
            } else {
               this.setRowSelectionInterval(var5.getRow(), var5.getRow());
               this.setColumnSelectionInterval(var5.getColumn(), var5.getColumn());
            }
         }
      }

      DropLocation var10 = this.dropLocation;
      this.dropLocation = var5;
      this.firePropertyChange("dropLocation", var10, this.dropLocation);
      return var4;
   }

   public final DropLocation getDropLocation() {
      return this.dropLocation;
   }

   public void setAutoCreateRowSorter(boolean var1) {
      boolean var2 = this.autoCreateRowSorter;
      this.autoCreateRowSorter = var1;
      if (var1) {
         this.setRowSorter(new TableRowSorter(this.getModel()));
      }

      this.firePropertyChange("autoCreateRowSorter", var2, var1);
   }

   public boolean getAutoCreateRowSorter() {
      return this.autoCreateRowSorter;
   }

   public void setUpdateSelectionOnSort(boolean var1) {
      if (this.updateSelectionOnSort != var1) {
         this.updateSelectionOnSort = var1;
         this.firePropertyChange("updateSelectionOnSort", !var1, var1);
      }

   }

   public boolean getUpdateSelectionOnSort() {
      return this.updateSelectionOnSort;
   }

   public void setRowSorter(RowSorter<? extends TableModel> var1) {
      RowSorter var2 = null;
      if (this.sortManager != null) {
         var2 = this.sortManager.sorter;
         this.sortManager.dispose();
         this.sortManager = null;
      }

      this.rowModel = null;
      this.clearSelectionAndLeadAnchor();
      if (var1 != null) {
         this.sortManager = new SortManager(this, var1);
      }

      this.resizeAndRepaint();
      this.firePropertyChange("sorter", var2, var1);
   }

   public RowSorter<? extends TableModel> getRowSorter() {
      return this.sortManager != null ? this.sortManager.sorter : null;
   }

   public void setSelectionMode(int var1) {
      this.clearSelection();
      this.getSelectionModel().setSelectionMode(var1);
      this.getColumnModel().getSelectionModel().setSelectionMode(var1);
   }

   public void setRowSelectionAllowed(boolean var1) {
      boolean var2 = this.rowSelectionAllowed;
      this.rowSelectionAllowed = var1;
      if (var2 != var1) {
         this.repaint();
      }

      this.firePropertyChange("rowSelectionAllowed", var2, var1);
   }

   public boolean getRowSelectionAllowed() {
      return this.rowSelectionAllowed;
   }

   public void setColumnSelectionAllowed(boolean var1) {
      boolean var2 = this.columnModel.getColumnSelectionAllowed();
      this.columnModel.setColumnSelectionAllowed(var1);
      if (var2 != var1) {
         this.repaint();
      }

      this.firePropertyChange("columnSelectionAllowed", var2, var1);
   }

   public boolean getColumnSelectionAllowed() {
      return this.columnModel.getColumnSelectionAllowed();
   }

   public void setCellSelectionEnabled(boolean var1) {
      this.setRowSelectionAllowed(var1);
      this.setColumnSelectionAllowed(var1);
      boolean var2 = this.cellSelectionEnabled;
      this.cellSelectionEnabled = var1;
      this.firePropertyChange("cellSelectionEnabled", var2, var1);
   }

   public boolean getCellSelectionEnabled() {
      return this.getRowSelectionAllowed() && this.getColumnSelectionAllowed();
   }

   public void selectAll() {
      if (this.isEditing()) {
         this.removeEditor();
      }

      if (this.getRowCount() > 0 && this.getColumnCount() > 0) {
         ListSelectionModel var3 = this.selectionModel;
         var3.setValueIsAdjusting(true);
         int var1 = this.getAdjustedIndex(var3.getLeadSelectionIndex(), true);
         int var2 = this.getAdjustedIndex(var3.getAnchorSelectionIndex(), true);
         this.setRowSelectionInterval(0, this.getRowCount() - 1);
         if (var2 == -1) {
            var2 = var1;
         }

         if (var1 == -1) {
            var3.setAnchorSelectionIndex(-1);
            var3.setLeadSelectionIndex(-1);
         } else {
            var3.addSelectionInterval(var2, var1);
         }

         var3.setValueIsAdjusting(false);
         var3 = this.columnModel.getSelectionModel();
         var3.setValueIsAdjusting(true);
         var1 = this.getAdjustedIndex(var3.getLeadSelectionIndex(), false);
         var2 = this.getAdjustedIndex(var3.getAnchorSelectionIndex(), false);
         this.setColumnSelectionInterval(0, this.getColumnCount() - 1);
         if (var2 == -1) {
            var2 = var1;
         }

         if (var1 == -1) {
            var3.setAnchorSelectionIndex(-1);
            var3.setLeadSelectionIndex(-1);
         } else {
            var3.addSelectionInterval(var2, var1);
         }

         var3.setValueIsAdjusting(false);
      }

   }

   public void clearSelection() {
      this.selectionModel.clearSelection();
      this.columnModel.getSelectionModel().clearSelection();
   }

   private void clearSelectionAndLeadAnchor() {
      this.selectionModel.setValueIsAdjusting(true);
      this.columnModel.getSelectionModel().setValueIsAdjusting(true);
      this.clearSelection();
      this.selectionModel.setAnchorSelectionIndex(-1);
      this.selectionModel.setLeadSelectionIndex(-1);
      this.columnModel.getSelectionModel().setAnchorSelectionIndex(-1);
      this.columnModel.getSelectionModel().setLeadSelectionIndex(-1);
      this.selectionModel.setValueIsAdjusting(false);
      this.columnModel.getSelectionModel().setValueIsAdjusting(false);
   }

   private int getAdjustedIndex(int var1, boolean var2) {
      int var3 = var2 ? this.getRowCount() : this.getColumnCount();
      return var1 < var3 ? var1 : -1;
   }

   private int boundRow(int var1) throws IllegalArgumentException {
      if (var1 >= 0 && var1 < this.getRowCount()) {
         return var1;
      } else {
         throw new IllegalArgumentException("Row index out of range");
      }
   }

   private int boundColumn(int var1) {
      if (var1 >= 0 && var1 < this.getColumnCount()) {
         return var1;
      } else {
         throw new IllegalArgumentException("Column index out of range");
      }
   }

   public void setRowSelectionInterval(int var1, int var2) {
      this.selectionModel.setSelectionInterval(this.boundRow(var1), this.boundRow(var2));
   }

   public void setColumnSelectionInterval(int var1, int var2) {
      this.columnModel.getSelectionModel().setSelectionInterval(this.boundColumn(var1), this.boundColumn(var2));
   }

   public void addRowSelectionInterval(int var1, int var2) {
      this.selectionModel.addSelectionInterval(this.boundRow(var1), this.boundRow(var2));
   }

   public void addColumnSelectionInterval(int var1, int var2) {
      this.columnModel.getSelectionModel().addSelectionInterval(this.boundColumn(var1), this.boundColumn(var2));
   }

   public void removeRowSelectionInterval(int var1, int var2) {
      this.selectionModel.removeSelectionInterval(this.boundRow(var1), this.boundRow(var2));
   }

   public void removeColumnSelectionInterval(int var1, int var2) {
      this.columnModel.getSelectionModel().removeSelectionInterval(this.boundColumn(var1), this.boundColumn(var2));
   }

   public int getSelectedRow() {
      return this.selectionModel.getMinSelectionIndex();
   }

   public int getSelectedColumn() {
      return this.columnModel.getSelectionModel().getMinSelectionIndex();
   }

   public int[] getSelectedRows() {
      int var1 = this.selectionModel.getMinSelectionIndex();
      int var2 = this.selectionModel.getMaxSelectionIndex();
      if (var1 != -1 && var2 != -1) {
         int[] var3 = new int[1 + (var2 - var1)];
         int var4 = 0;

         for(int var5 = var1; var5 <= var2; ++var5) {
            if (this.selectionModel.isSelectedIndex(var5)) {
               var3[var4++] = var5;
            }
         }

         int[] var6 = new int[var4];
         System.arraycopy(var3, 0, var6, 0, var4);
         return var6;
      } else {
         return new int[0];
      }
   }

   public int[] getSelectedColumns() {
      return this.columnModel.getSelectedColumns();
   }

   public int getSelectedRowCount() {
      int var1 = this.selectionModel.getMinSelectionIndex();
      int var2 = this.selectionModel.getMaxSelectionIndex();
      int var3 = 0;

      for(int var4 = var1; var4 <= var2; ++var4) {
         if (this.selectionModel.isSelectedIndex(var4)) {
            ++var3;
         }
      }

      return var3;
   }

   public int getSelectedColumnCount() {
      return this.columnModel.getSelectedColumnCount();
   }

   public boolean isRowSelected(int var1) {
      return this.selectionModel.isSelectedIndex(var1);
   }

   public boolean isColumnSelected(int var1) {
      return this.columnModel.getSelectionModel().isSelectedIndex(var1);
   }

   public boolean isCellSelected(int var1, int var2) {
      if (!this.getRowSelectionAllowed() && !this.getColumnSelectionAllowed()) {
         return false;
      } else {
         return (!this.getRowSelectionAllowed() || this.isRowSelected(var1)) && (!this.getColumnSelectionAllowed() || this.isColumnSelected(var2));
      }
   }

   private void changeSelectionModel(ListSelectionModel var1, int var2, boolean var3, boolean var4, boolean var5, int var6, boolean var7) {
      if (var4) {
         if (var3) {
            if (var7) {
               var1.addSelectionInterval(var6, var2);
            } else {
               var1.removeSelectionInterval(var6, var2);
               if (Boolean.TRUE == this.getClientProperty("Table.isFileList")) {
                  var1.addSelectionInterval(var2, var2);
                  var1.setAnchorSelectionIndex(var6);
               }
            }
         } else {
            var1.setSelectionInterval(var6, var2);
         }
      } else if (var3) {
         if (var5) {
            var1.removeSelectionInterval(var2, var2);
         } else {
            var1.addSelectionInterval(var2, var2);
         }
      } else {
         var1.setSelectionInterval(var2, var2);
      }

   }

   public void changeSelection(int var1, int var2, boolean var3, boolean var4) {
      ListSelectionModel var5 = this.getSelectionModel();
      ListSelectionModel var6 = this.getColumnModel().getSelectionModel();
      int var7 = this.getAdjustedIndex(var5.getAnchorSelectionIndex(), true);
      int var8 = this.getAdjustedIndex(var6.getAnchorSelectionIndex(), false);
      boolean var9 = true;
      if (var7 == -1) {
         var7 = 0;
         var9 = false;
      }

      if (var8 == -1) {
         var8 = 0;
         var9 = false;
      }

      boolean var10 = this.isCellSelected(var1, var2);
      var9 = var9 && this.isCellSelected(var7, var8);
      this.changeSelectionModel(var6, var2, var3, var4, var10, var8, var9);
      this.changeSelectionModel(var5, var1, var3, var4, var10, var7, var9);
      if (this.getAutoscrolls()) {
         Rectangle var11 = this.getCellRect(var1, var2, false);
         if (var11 != null) {
            this.scrollRectToVisible(var11);
         }
      }

   }

   public Color getSelectionForeground() {
      return this.selectionForeground;
   }

   public void setSelectionForeground(Color var1) {
      Color var2 = this.selectionForeground;
      this.selectionForeground = var1;
      this.firePropertyChange("selectionForeground", var2, var1);
      if (!var1.equals(var2)) {
         this.repaint();
      }

   }

   public Color getSelectionBackground() {
      return this.selectionBackground;
   }

   public void setSelectionBackground(Color var1) {
      Color var2 = this.selectionBackground;
      this.selectionBackground = var1;
      this.firePropertyChange("selectionBackground", var2, var1);
      if (!var1.equals(var2)) {
         this.repaint();
      }

   }

   public TableColumn getColumn(Object var1) {
      TableColumnModel var2 = this.getColumnModel();
      int var3 = var2.getColumnIndex(var1);
      return var2.getColumn(var3);
   }

   public int convertColumnIndexToModel(int var1) {
      return var1 < 0 ? var1 : this.getColumnModel().getColumn(var1).getModelIndex();
   }

   public int convertColumnIndexToView(int var1) {
      if (var1 < 0) {
         return var1;
      } else {
         TableColumnModel var2 = this.getColumnModel();

         for(int var3 = 0; var3 < this.getColumnCount(); ++var3) {
            if (var2.getColumn(var3).getModelIndex() == var1) {
               return var3;
            }
         }

         return -1;
      }
   }

   public int convertRowIndexToView(int var1) {
      RowSorter var2 = this.getRowSorter();
      return var2 != null ? var2.convertRowIndexToView(var1) : var1;
   }

   public int convertRowIndexToModel(int var1) {
      RowSorter var2 = this.getRowSorter();
      return var2 != null ? var2.convertRowIndexToModel(var1) : var1;
   }

   public int getRowCount() {
      RowSorter var1 = this.getRowSorter();
      return var1 != null ? var1.getViewRowCount() : this.getModel().getRowCount();
   }

   public int getColumnCount() {
      return this.getColumnModel().getColumnCount();
   }

   public String getColumnName(int var1) {
      return this.getModel().getColumnName(this.convertColumnIndexToModel(var1));
   }

   public Class<?> getColumnClass(int var1) {
      return this.getModel().getColumnClass(this.convertColumnIndexToModel(var1));
   }

   public Object getValueAt(int var1, int var2) {
      return this.getModel().getValueAt(this.convertRowIndexToModel(var1), this.convertColumnIndexToModel(var2));
   }

   public void setValueAt(Object var1, int var2, int var3) {
      this.getModel().setValueAt(var1, this.convertRowIndexToModel(var2), this.convertColumnIndexToModel(var3));
   }

   public boolean isCellEditable(int var1, int var2) {
      return this.getModel().isCellEditable(this.convertRowIndexToModel(var1), this.convertColumnIndexToModel(var2));
   }

   public void addColumn(TableColumn var1) {
      if (var1.getHeaderValue() == null) {
         int var2 = var1.getModelIndex();
         String var3 = this.getModel().getColumnName(var2);
         var1.setHeaderValue(var3);
      }

      this.getColumnModel().addColumn(var1);
   }

   public void removeColumn(TableColumn var1) {
      this.getColumnModel().removeColumn(var1);
   }

   public void moveColumn(int var1, int var2) {
      this.getColumnModel().moveColumn(var1, var2);
   }

   public int columnAtPoint(Point var1) {
      int var2 = var1.x;
      if (!this.getComponentOrientation().isLeftToRight()) {
         var2 = this.getWidth() - var2;
      }

      return this.getColumnModel().getColumnIndexAtX(var2);
   }

   public int rowAtPoint(Point var1) {
      int var2 = var1.y;
      int var3 = this.rowModel == null ? var2 / this.getRowHeight() : this.rowModel.getIndex(var2);
      if (var3 < 0) {
         return -1;
      } else {
         return var3 >= this.getRowCount() ? -1 : var3;
      }
   }

   public Rectangle getCellRect(int var1, int var2, boolean var3) {
      Rectangle var4 = new Rectangle();
      boolean var5 = true;
      if (var1 < 0) {
         var5 = false;
      } else if (var1 >= this.getRowCount()) {
         var4.y = this.getHeight();
         var5 = false;
      } else {
         var4.height = this.getRowHeight(var1);
         var4.y = this.rowModel == null ? var1 * var4.height : this.rowModel.getPosition(var1);
      }

      if (var2 < 0) {
         if (!this.getComponentOrientation().isLeftToRight()) {
            var4.x = this.getWidth();
         }

         var5 = false;
      } else if (var2 >= this.getColumnCount()) {
         if (this.getComponentOrientation().isLeftToRight()) {
            var4.x = this.getWidth();
         }

         var5 = false;
      } else {
         TableColumnModel var6 = this.getColumnModel();
         if (this.getComponentOrientation().isLeftToRight()) {
            for(int var9 = 0; var9 < var2; ++var9) {
               var4.x += var6.getColumn(var9).getWidth();
            }
         } else {
            for(int var7 = var6.getColumnCount() - 1; var7 > var2; --var7) {
               var4.x += var6.getColumn(var7).getWidth();
            }
         }

         var4.width = var6.getColumn(var2).getWidth();
      }

      if (var5 && !var3) {
         int var8 = Math.min(this.getRowMargin(), var4.height);
         int var10 = Math.min(this.getColumnModel().getColumnMargin(), var4.width);
         var4.setBounds(var4.x + var10 / 2, var4.y + var8 / 2, var4.width - var10, var4.height - var8);
      }

      return var4;
   }

   private int viewIndexForColumn(TableColumn var1) {
      TableColumnModel var2 = this.getColumnModel();

      for(int var3 = 0; var3 < var2.getColumnCount(); ++var3) {
         if (var2.getColumn(var3) == var1) {
            return var3;
         }
      }

      return -1;
   }

   public void doLayout() {
      TableColumn var1 = this.getResizingColumn();
      if (var1 == null) {
         this.setWidthsFromPreferredWidths(false);
      } else {
         int var2 = this.viewIndexForColumn(var1);
         int var3 = this.getWidth() - this.getColumnModel().getTotalColumnWidth();
         this.accommodateDelta(var2, var3);
         var3 = this.getWidth() - this.getColumnModel().getTotalColumnWidth();
         if (var3 != 0) {
            var1.setWidth(var1.getWidth() + var3);
         }

         this.setWidthsFromPreferredWidths(true);
      }

      super.doLayout();
   }

   private TableColumn getResizingColumn() {
      return this.tableHeader == null ? null : this.tableHeader.getResizingColumn();
   }

   /** @deprecated */
   @Deprecated
   public void sizeColumnsToFit(boolean var1) {
      int var2 = this.autoResizeMode;
      this.setAutoResizeMode(var1 ? 3 : 4);
      this.sizeColumnsToFit(-1);
      this.setAutoResizeMode(var2);
   }

   public void sizeColumnsToFit(int var1) {
      if (var1 == -1) {
         this.setWidthsFromPreferredWidths(false);
      } else if (this.autoResizeMode == 0) {
         TableColumn var2 = this.getColumnModel().getColumn(var1);
         var2.setPreferredWidth(var2.getWidth());
      } else {
         int var3 = this.getWidth() - this.getColumnModel().getTotalColumnWidth();
         this.accommodateDelta(var1, var3);
         this.setWidthsFromPreferredWidths(true);
      }

   }

   private void setWidthsFromPreferredWidths(boolean var1) {
      int var2 = this.getWidth();
      int var3 = this.getPreferredSize().width;
      int var4 = !var1 ? var2 : var3;
      TableColumnModel var5 = this.columnModel;
      2 var6 = new 2(this, var5, var1);
      this.adjustSizes((long)var4, (Resizable3)var6, var1);
   }

   private void accommodateDelta(int var1, int var2) {
      int var3 = this.getColumnCount();
      int var4;
      int var5;
      switch (this.autoResizeMode) {
         case 1:
            var4 = var1 + 1;
            var5 = Math.min(var4 + 1, var3);
            break;
         case 2:
            var4 = var1 + 1;
            var5 = var3;
            break;
         case 3:
            var4 = var3 - 1;
            var5 = var4 + 1;
            break;
         case 4:
            var4 = 0;
            var5 = var3;
            break;
         default:
            return;
      }

      TableColumnModel var8 = this.columnModel;
      3 var9 = new 3(this, var5, var4, var8);
      int var10 = 0;

      for(int var11 = var4; var11 < var5; ++var11) {
         TableColumn var12 = this.columnModel.getColumn(var11);
         int var13 = var12.getWidth();
         var10 += var13;
      }

      this.adjustSizes((long)(var10 + var2), (Resizable3)var9, false);
   }

   private void adjustSizes(long var1, Resizable3 var3, boolean var4) {
      int var5 = var3.getElementCount();
      long var6 = 0L;

      for(int var8 = 0; var8 < var5; ++var8) {
         var6 += (long)var3.getMidPointAt(var8);
      }

      Object var9;
      if (var1 < var6 == !var4) {
         var9 = new 4(this, var3);
      } else {
         var9 = new 5(this, var3);
      }

      this.adjustSizes(var1, (Resizable2)var9, !var4);
   }

   private void adjustSizes(long var1, Resizable2 var3, boolean var4) {
      long var5 = 0L;
      long var7 = 0L;

      for(int var9 = 0; var9 < var3.getElementCount(); ++var9) {
         var5 += (long)var3.getLowerBoundAt(var9);
         var7 += (long)var3.getUpperBoundAt(var9);
      }

      if (var4) {
         var1 = Math.min(Math.max(var5, var1), var7);
      }

      for(int var15 = 0; var15 < var3.getElementCount(); ++var15) {
         int var10 = var3.getLowerBoundAt(var15);
         int var11 = var3.getUpperBoundAt(var15);
         int var12;
         if (var5 == var7) {
            var12 = var10;
         } else {
            double var13 = (double)(var1 - var5) / (double)(var7 - var5);
            var12 = (int)Math.round((double)var10 + var13 * (double)(var11 - var10));
         }

         var3.setSizeAt(var12, var15);
         var1 -= (long)var12;
         var5 -= (long)var10;
         var7 -= (long)var11;
      }

   }

   public String getToolTipText(MouseEvent var1) {
      String var2 = null;
      Point var3 = var1.getPoint();
      int var4 = this.columnAtPoint(var3);
      int var5 = this.rowAtPoint(var3);
      if (var4 != -1 && var5 != -1) {
         TableCellRenderer var6 = this.getCellRenderer(var5, var4);
         Component var7 = this.prepareRenderer(var6, var5, var4);
         if (var7 instanceof JComponent) {
            Rectangle var8 = this.getCellRect(var5, var4, false);
            var3.translate(-var8.x, -var8.y);
            MouseEvent var9 = new MouseEvent(var7, var1.getID(), var1.getWhen(), var1.getModifiers(), var3.x, var3.y, var1.getXOnScreen(), var1.getYOnScreen(), var1.getClickCount(), var1.isPopupTrigger(), 0);
            var2 = ((JComponent)var7).getToolTipText(var9);
         }
      }

      if (var2 == null) {
         var2 = this.getToolTipText();
      }

      return var2;
   }

   public void setSurrendersFocusOnKeystroke(boolean var1) {
      this.surrendersFocusOnKeystroke = var1;
   }

   public boolean getSurrendersFocusOnKeystroke() {
      return this.surrendersFocusOnKeystroke;
   }

   public boolean editCellAt(int var1, int var2) {
      return this.editCellAt(var1, var2, (EventObject)null);
   }

   public boolean editCellAt(int var1, int var2, EventObject var3) {
      if (this.cellEditor != null && !this.cellEditor.stopCellEditing()) {
         return false;
      } else if (var1 >= 0 && var1 < this.getRowCount() && var2 >= 0 && var2 < this.getColumnCount()) {
         if (!this.isCellEditable(var1, var2)) {
            return false;
         } else {
            if (this.editorRemover == null) {
               KeyboardFocusManager var4 = KeyboardFocusManager.getCurrentKeyboardFocusManager();
               this.editorRemover = new CellEditorRemover(this, var4);
               var4.addPropertyChangeListener("permanentFocusOwner", this.editorRemover);
            }

            TableCellEditor var5 = this.getCellEditor(var1, var2);
            if (var5 != null && var5.isCellEditable(var3)) {
               this.editorComp = this.prepareEditor(var5, var1, var2);
               if (this.editorComp == null) {
                  this.removeEditor();
                  return false;
               } else {
                  this.editorComp.setBounds(this.getCellRect(var1, var2, false));
                  this.add(this.editorComp);
                  this.editorComp.validate();
                  this.editorComp.repaint();
                  this.setCellEditor(var5);
                  this.setEditingRow(var1);
                  this.setEditingColumn(var2);
                  var5.addCellEditorListener(this);
                  return true;
               }
            } else {
               return false;
            }
         }
      } else {
         return false;
      }
   }

   public boolean isEditing() {
      return this.cellEditor != null;
   }

   public Component getEditorComponent() {
      return this.editorComp;
   }

   public int getEditingColumn() {
      return this.editingColumn;
   }

   public int getEditingRow() {
      return this.editingRow;
   }

   public TableUI getUI() {
      return (TableUI)this.ui;
   }

   public void setUI(TableUI var1) {
      if (this.ui != var1) {
         super.setUI(var1);
         this.repaint();
      }

   }

   private void updateSubComponentUI(Object var1) {
      if (var1 != null) {
         Component var2 = null;
         if (var1 instanceof Component) {
            var2 = (Component)var1;
         }

         if (var1 instanceof DefaultCellEditor) {
            var2 = ((DefaultCellEditor)var1).getComponent();
         }

         if (var2 != null) {
            SwingUtilities.updateComponentTreeUI(var2);
         }

      }
   }

   public void updateUI() {
      TableColumnModel var1 = this.getColumnModel();

      for(int var2 = 0; var2 < var1.getColumnCount(); ++var2) {
         TableColumn var3 = var1.getColumn(var2);
         this.updateSubComponentUI(var3.getCellRenderer());
         this.updateSubComponentUI(var3.getCellEditor());
         this.updateSubComponentUI(var3.getHeaderRenderer());
      }

      Enumeration var4 = this.defaultRenderersByColumnClass.elements();

      while(var4.hasMoreElements()) {
         this.updateSubComponentUI(var4.nextElement());
      }

      Enumeration var5 = this.defaultEditorsByColumnClass.elements();

      while(var5.hasMoreElements()) {
         this.updateSubComponentUI(var5.nextElement());
      }

      if (this.tableHeader != null && this.tableHeader.getParent() == null) {
         this.tableHeader.updateUI();
      }

      this.setUI((TableUI)UIManager.getUI(this));
   }

   public String getUIClassID() {
      return "TableUI";
   }

   public void setModel(TableModel var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("Cannot set a null TableModel");
      } else {
         if (this.dataModel != var1) {
            TableModel var2 = this.dataModel;
            if (var2 != null) {
               var2.removeTableModelListener(this);
            }

            this.dataModel = var1;
            var1.addTableModelListener(this);
            this.tableChanged(new TableModelEvent(var1, -1));
            this.firePropertyChange("model", var2, var1);
            if (this.getAutoCreateRowSorter()) {
               this.setRowSorter(new TableRowSorter(var1));
            }
         }

      }
   }

   public TableModel getModel() {
      return this.dataModel;
   }

   public void setColumnModel(TableColumnModel var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("Cannot set a null ColumnModel");
      } else {
         TableColumnModel var2 = this.columnModel;
         if (var1 != var2) {
            if (var2 != null) {
               var2.removeColumnModelListener(this);
            }

            this.columnModel = var1;
            var1.addColumnModelListener(this);
            if (this.tableHeader != null) {
               this.tableHeader.setColumnModel(var1);
            }

            this.firePropertyChange("columnModel", var2, var1);
            this.resizeAndRepaint();
         }

      }
   }

   public TableColumnModel getColumnModel() {
      return this.columnModel;
   }

   public void setSelectionModel(ListSelectionModel var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("Cannot set a null SelectionModel");
      } else {
         ListSelectionModel var2 = this.selectionModel;
         if (var1 != var2) {
            if (var2 != null) {
               var2.removeListSelectionListener(this);
            }

            this.selectionModel = var1;
            var1.addListSelectionListener(this);
            this.firePropertyChange("selectionModel", var2, var1);
            this.repaint();
         }

      }
   }

   public ListSelectionModel getSelectionModel() {
      return this.selectionModel;
   }

   public void sorterChanged(RowSorterEvent var1) {
      if (var1.getType() == Type.SORT_ORDER_CHANGED) {
         JTableHeader var2 = this.getTableHeader();
         if (var2 != null) {
            var2.repaint();
         }
      } else if (var1.getType() == Type.SORTED) {
         this.sorterChanged = true;
         if (!this.ignoreSortChange) {
            this.sortedTableChanged(var1, (TableModelEvent)null);
         }
      }

   }

   private void sortedTableChanged(RowSorterEvent var1, TableModelEvent var2) {
      int var3 = -1;
      ModelChange var4 = var2 != null ? new ModelChange(this, var2) : null;
      if ((var4 == null || !var4.allRowsChanged) && this.editingRow != -1) {
         var3 = this.convertRowIndexToModel(var1, this.editingRow);
      }

      this.sortManager.prepareForChange(var1, var4);
      if (var2 != null) {
         if (var4.type == 0) {
            this.repaintSortedRows(var4);
         }

         this.notifySorter(var4);
         if (var4.type != 0) {
            this.sorterChanged = true;
         }
      } else {
         this.sorterChanged = true;
      }

      this.sortManager.processChange(var1, var4, this.sorterChanged);
      if (this.sorterChanged) {
         if (this.editingRow != -1) {
            int var5 = var3 == -1 ? -1 : this.convertRowIndexToView(var3, var4);
            this.restoreSortingEditingRow(var5);
         }

         if (var2 == null || var4.type != 0) {
            this.resizeAndRepaint();
         }
      }

      if (var4 != null && var4.allRowsChanged) {
         this.clearSelectionAndLeadAnchor();
         this.resizeAndRepaint();
      }

   }

   private void repaintSortedRows(ModelChange var1) {
      if (var1.startModelIndex <= var1.endModelIndex && var1.startModelIndex + 10 >= var1.endModelIndex) {
         int var2 = var1.event.getColumn();
         int var3;
         if (var2 == -1) {
            var3 = 0;
         } else {
            var3 = this.convertColumnIndexToView(var2);
            if (var3 == -1) {
               return;
            }
         }

         int var4 = var1.startModelIndex;

         while(var4 <= var1.endModelIndex) {
            int var5 = this.convertRowIndexToView(var4++);
            if (var5 != -1) {
               Rectangle var6 = this.getCellRect(var5, var3, false);
               int var7 = var6.x;
               int var8 = var6.width;
               if (var2 == -1) {
                  var7 = 0;
                  var8 = this.getWidth();
               }

               this.repaint(var7, var6.y, var8, var6.height);
            }
         }

      } else {
         this.repaint();
      }
   }

   private void restoreSortingSelection(int[] var1, int var2, ModelChange var3) {
      for(int var4 = var1.length - 1; var4 >= 0; --var4) {
         var1[var4] = this.convertRowIndexToView(var1[var4], var3);
      }

      var2 = this.convertRowIndexToView(var2, var3);
      if (var1.length != 0 && (var1.length != 1 || var1[0] != this.getSelectedRow())) {
         this.selectionModel.setValueIsAdjusting(true);
         this.selectionModel.clearSelection();

         for(int var6 = var1.length - 1; var6 >= 0; --var6) {
            if (var1[var6] != -1) {
               this.selectionModel.addSelectionInterval(var1[var6], var1[var6]);
            }
         }

         SwingUtilities2.setLeadAnchorWithoutSelection(this.selectionModel, var2, var2);
         this.selectionModel.setValueIsAdjusting(false);
      }
   }

   private void restoreSortingEditingRow(int var1) {
      if (var1 == -1) {
         TableCellEditor var2 = this.getCellEditor();
         if (var2 != null) {
            var2.cancelCellEditing();
            if (this.getCellEditor() != null) {
               this.removeEditor();
            }
         }
      } else {
         this.editingRow = var1;
         this.repaint();
      }

   }

   private void notifySorter(ModelChange var1) {
      try {
         this.ignoreSortChange = true;
         this.sorterChanged = false;
         switch (var1.type) {
            case -1:
               this.sortManager.sorter.rowsDeleted(var1.startModelIndex, var1.endModelIndex);
               break;
            case 0:
               if (var1.event.getLastRow() == Integer.MAX_VALUE) {
                  this.sortManager.sorter.allRowsChanged();
               } else if (var1.event.getColumn() == -1) {
                  this.sortManager.sorter.rowsUpdated(var1.startModelIndex, var1.endModelIndex);
               } else {
                  this.sortManager.sorter.rowsUpdated(var1.startModelIndex, var1.endModelIndex, var1.event.getColumn());
               }
               break;
            case 1:
               this.sortManager.sorter.rowsInserted(var1.startModelIndex, var1.endModelIndex);
         }
      } finally {
         this.ignoreSortChange = false;
      }

   }

   private int convertRowIndexToView(int var1, ModelChange var2) {
      if (var1 < 0) {
         return -1;
      } else {
         if (var2 != null && var1 >= var2.startModelIndex) {
            if (var2.type == 1) {
               if (var1 + var2.length >= var2.modelRowCount) {
                  return -1;
               }

               return this.sortManager.sorter.convertRowIndexToView(var1 + var2.length);
            }

            if (var2.type == -1) {
               if (var1 <= var2.endModelIndex) {
                  return -1;
               }

               if (var1 - var2.length >= var2.modelRowCount) {
                  return -1;
               }

               return this.sortManager.sorter.convertRowIndexToView(var1 - var2.length);
            }
         }

         return var1 >= this.getModel().getRowCount() ? -1 : this.sortManager.sorter.convertRowIndexToView(var1);
      }
   }

   private int[] convertSelectionToModel(RowSorterEvent var1) {
      int[] var2 = this.getSelectedRows();

      for(int var3 = var2.length - 1; var3 >= 0; --var3) {
         var2[var3] = this.convertRowIndexToModel(var1, var2[var3]);
      }

      return var2;
   }

   private int convertRowIndexToModel(RowSorterEvent var1, int var2) {
      if (var1 != null) {
         return var1.getPreviousRowCount() == 0 ? var2 : var1.convertPreviousRowIndexToModel(var2);
      } else {
         return var2 >= 0 && var2 < this.getRowCount() ? this.convertRowIndexToModel(var2) : -1;
      }
   }

   public void tableChanged(TableModelEvent var1) {
      if (var1 != null && var1.getFirstRow() != -1) {
         if (this.sortManager != null) {
            this.sortedTableChanged((RowSorterEvent)null, var1);
         } else {
            if (this.rowModel != null) {
               this.repaint();
            }

            if (var1.getType() == 1) {
               this.tableRowsInserted(var1);
            } else if (var1.getType() == -1) {
               this.tableRowsDeleted(var1);
            } else {
               int var2 = var1.getColumn();
               int var3 = var1.getFirstRow();
               int var4 = var1.getLastRow();
               Rectangle var5;
               if (var2 == -1) {
                  var5 = new Rectangle(0, var3 * this.getRowHeight(), this.getColumnModel().getTotalColumnWidth(), 0);
               } else {
                  int var6 = this.convertColumnIndexToView(var2);
                  var5 = this.getCellRect(var3, var6, false);
               }

               if (var4 != Integer.MAX_VALUE) {
                  var5.height = (var4 - var3 + 1) * this.getRowHeight();
                  this.repaint(var5.x, var5.y, var5.width, var5.height);
               } else {
                  this.clearSelectionAndLeadAnchor();
                  this.resizeAndRepaint();
                  this.rowModel = null;
               }

            }
         }
      } else {
         this.clearSelectionAndLeadAnchor();
         this.rowModel = null;
         if (this.sortManager != null) {
            try {
               this.ignoreSortChange = true;
               this.sortManager.sorter.modelStructureChanged();
            } finally {
               this.ignoreSortChange = false;
            }

            this.sortManager.allChanged();
         }

         if (this.getAutoCreateColumnsFromModel()) {
            this.createDefaultColumnsFromModel();
         } else {
            this.resizeAndRepaint();
         }
      }
   }

   private void tableRowsInserted(TableModelEvent var1) {
      int var2 = var1.getFirstRow();
      int var3 = var1.getLastRow();
      if (var2 < 0) {
         var2 = 0;
      }

      if (var3 < 0) {
         var3 = this.getRowCount() - 1;
      }

      int var4 = var3 - var2 + 1;
      this.selectionModel.insertIndexInterval(var2, var4, true);
      if (this.rowModel != null) {
         this.rowModel.insertEntries(var2, var4, this.getRowHeight());
      }

      int var5 = this.getRowHeight();
      Rectangle var6 = new Rectangle(0, var2 * var5, this.getColumnModel().getTotalColumnWidth(), (this.getRowCount() - var2) * var5);
      this.revalidate();
      this.repaint(var6);
   }

   private void tableRowsDeleted(TableModelEvent var1) {
      int var2 = var1.getFirstRow();
      int var3 = var1.getLastRow();
      if (var2 < 0) {
         var2 = 0;
      }

      if (var3 < 0) {
         var3 = this.getRowCount() - 1;
      }

      int var4 = var3 - var2 + 1;
      int var5 = this.getRowCount() + var4;
      this.selectionModel.removeIndexInterval(var2, var3);
      if (this.rowModel != null) {
         this.rowModel.removeEntries(var2, var4);
      }

      int var6 = this.getRowHeight();
      Rectangle var7 = new Rectangle(0, var2 * var6, this.getColumnModel().getTotalColumnWidth(), (var5 - var2) * var6);
      this.revalidate();
      this.repaint(var7);
   }

   public void columnAdded(TableColumnModelEvent var1) {
      if (this.isEditing()) {
         this.removeEditor();
      }

      this.resizeAndRepaint();
   }

   public void columnRemoved(TableColumnModelEvent var1) {
      if (this.isEditing()) {
         this.removeEditor();
      }

      this.resizeAndRepaint();
   }

   public void columnMoved(TableColumnModelEvent var1) {
      if (this.isEditing()) {
         this.removeEditor();
      }

      this.repaint();
   }

   public void columnMarginChanged(ChangeEvent var1) {
      if (this.isEditing()) {
         this.removeEditor();
      }

      TableColumn var2 = this.getResizingColumn();
      if (var2 != null && this.autoResizeMode == 0) {
         var2.setPreferredWidth(var2.getWidth());
      }

      this.resizeAndRepaint();
   }

   private int limit(int var1, int var2, int var3) {
      return Math.min(var3, Math.max(var1, var2));
   }

   public void columnSelectionChanged(ListSelectionEvent var1) {
      boolean var2 = var1.getValueIsAdjusting();
      if (this.columnSelectionAdjusting && !var2) {
         this.columnSelectionAdjusting = false;
      } else {
         this.columnSelectionAdjusting = var2;
         if (this.getRowCount() > 0 && this.getColumnCount() > 0) {
            int var3 = this.limit(var1.getFirstIndex(), 0, this.getColumnCount() - 1);
            int var4 = this.limit(var1.getLastIndex(), 0, this.getColumnCount() - 1);
            int var5 = 0;
            int var6 = this.getRowCount() - 1;
            if (this.getRowSelectionAllowed()) {
               var5 = this.selectionModel.getMinSelectionIndex();
               var6 = this.selectionModel.getMaxSelectionIndex();
               int var7 = this.getAdjustedIndex(this.selectionModel.getLeadSelectionIndex(), true);
               if (var5 != -1 && var6 != -1) {
                  if (var7 != -1) {
                     var5 = Math.min(var5, var7);
                     var6 = Math.max(var6, var7);
                  }
               } else {
                  if (var7 == -1) {
                     return;
                  }

                  var6 = var7;
                  var5 = var7;
               }
            }

            Rectangle var10 = this.getCellRect(var5, var3, false);
            Rectangle var8 = this.getCellRect(var6, var4, false);
            Rectangle var9 = var10.union(var8);
            this.repaint(var9);
         }
      }
   }

   public void valueChanged(ListSelectionEvent var1) {
      if (this.sortManager != null) {
         this.sortManager.viewSelectionChanged(var1);
      }

      boolean var2 = var1.getValueIsAdjusting();
      if (this.rowSelectionAdjusting && !var2) {
         this.rowSelectionAdjusting = false;
      } else {
         this.rowSelectionAdjusting = var2;
         if (this.getRowCount() > 0 && this.getColumnCount() > 0) {
            int var3 = this.limit(var1.getFirstIndex(), 0, this.getRowCount() - 1);
            int var4 = this.limit(var1.getLastIndex(), 0, this.getRowCount() - 1);
            Rectangle var5 = this.getCellRect(var3, 0, false);
            Rectangle var6 = this.getCellRect(var4, this.getColumnCount() - 1, false);
            Rectangle var7 = var5.union(var6);
            this.repaint(var7);
         }
      }
   }

   public void editingStopped(ChangeEvent var1) {
      TableCellEditor var2 = this.getCellEditor();
      if (var2 != null) {
         Object var3 = var2.getCellEditorValue();
         this.setValueAt(var3, this.editingRow, this.editingColumn);
         this.removeEditor();
      }

   }

   public void editingCanceled(ChangeEvent var1) {
      this.removeEditor();
   }

   public void setPreferredScrollableViewportSize(Dimension var1) {
      this.preferredViewportSize = var1;
   }

   public Dimension getPreferredScrollableViewportSize() {
      return this.preferredViewportSize;
   }

   public int getScrollableUnitIncrement(Rectangle var1, int var2, int var3) {
      int var4 = this.getLeadingRow(var1);
      int var5 = this.getLeadingCol(var1);
      if (var2 == 1 && var4 < 0) {
         return this.getRowHeight();
      } else if (var2 == 0 && var5 < 0) {
         return 100;
      } else {
         Rectangle var6 = this.getCellRect(var4, var5, true);
         int var7 = this.leadingEdge(var1, var2);
         int var8 = this.leadingEdge(var6, var2);
         int var9;
         if (var2 == 1) {
            var9 = var6.height;
         } else {
            var9 = var6.width;
         }

         if (var7 == var8) {
            if (var3 >= 0) {
               return var9;
            } else {
               int var12 = 0;
               if (var2 == 1) {
                  do {
                     --var4;
                     if (var4 < 0) {
                        break;
                     }

                     var12 = this.getRowHeight(var4);
                  } while(var12 == 0);
               } else {
                  do {
                     --var5;
                     if (var5 < 0) {
                        break;
                     }

                     var12 = this.getCellRect(var4, var5, true).width;
                  } while(var12 == 0);
               }

               return var12;
            }
         } else {
            int var10 = Math.abs(var7 - var8);
            int var11 = var9 - var10;
            return var3 > 0 ? var11 : var10;
         }
      }
   }

   public int getScrollableBlockIncrement(Rectangle var1, int var2, int var3) {
      if (this.getRowCount() == 0) {
         if (1 == var2) {
            int var8 = this.getRowHeight();
            return var8 > 0 ? Math.max(var8, var1.height / var8 * var8) : var1.height;
         } else {
            return var1.width;
         }
      } else {
         if (null == this.rowModel && 1 == var2) {
            int var4 = this.rowAtPoint(var1.getLocation());

            assert var4 != -1;

            int var5 = this.columnAtPoint(var1.getLocation());
            Rectangle var6 = this.getCellRect(var4, var5, true);
            if (var6.y == var1.y) {
               int var7 = this.getRowHeight();

               assert var7 > 0;

               return Math.max(var7, var1.height / var7 * var7);
            }
         }

         return var3 < 0 ? this.getPreviousBlockIncrement(var1, var2) : this.getNextBlockIncrement(var1, var2);
      }
   }

   private int getPreviousBlockIncrement(Rectangle var1, int var2) {
      int var7 = this.leadingEdge(var1, var2);
      boolean var8 = this.getComponentOrientation().isLeftToRight();
      int var5;
      Point var6;
      if (var2 == 1) {
         var5 = var7 - var1.height;
         int var10 = var1.x + (var8 ? 0 : var1.width);
         var6 = new Point(var10, var5);
      } else if (var8) {
         var5 = var7 - var1.width;
         var6 = new Point(var5, var1.y);
      } else {
         var5 = var7 + var1.width;
         var6 = new Point(var5, var1.y);
      }

      int var3 = this.rowAtPoint(var6);
      int var4 = this.columnAtPoint(var6);
      int var9;
      if (var2 == 1 & var3 < 0) {
         var9 = 0;
      } else if (var2 == 0 & var4 < 0) {
         if (var8) {
            var9 = 0;
         } else {
            var9 = this.getWidth();
         }
      } else {
         Rectangle var13 = this.getCellRect(var3, var4, true);
         int var11 = this.leadingEdge(var13, var2);
         int var12 = this.trailingEdge(var13, var2);
         if ((var2 == 1 || var8) && var12 >= var7) {
            var9 = var11;
         } else if (var2 == 0 && !var8 && var12 <= var7) {
            var9 = var11;
         } else if (var5 == var11) {
            var9 = var11;
         } else {
            var9 = var12;
         }
      }

      return Math.abs(var7 - var9);
   }

   private int getNextBlockIncrement(Rectangle var1, int var2) {
      int var3 = this.getTrailingRow(var1);
      int var4 = this.getTrailingCol(var1);
      int var10 = this.leadingEdge(var1, var2);
      if (var2 == 1 && var3 < 0) {
         return var1.height;
      } else if (var2 == 0 && var4 < 0) {
         return var1.width;
      } else {
         Rectangle var5 = this.getCellRect(var3, var4, true);
         int var7 = this.leadingEdge(var5, var2);
         int var8 = this.trailingEdge(var5, var2);
         boolean var6;
         if (var2 != 1 && !this.getComponentOrientation().isLeftToRight()) {
            var6 = var7 >= var10;
         } else {
            var6 = var7 <= var10;
         }

         int var9;
         if (var6) {
            var9 = var8;
         } else if (var8 == this.trailingEdge(var1, var2)) {
            var9 = var8;
         } else {
            var9 = var7;
         }

         return Math.abs(var9 - var10);
      }
   }

   private int getLeadingRow(Rectangle var1) {
      Point var2;
      if (this.getComponentOrientation().isLeftToRight()) {
         var2 = new Point(var1.x, var1.y);
      } else {
         var2 = new Point(var1.x + var1.width, var1.y);
      }

      return this.rowAtPoint(var2);
   }

   private int getLeadingCol(Rectangle var1) {
      Point var2;
      if (this.getComponentOrientation().isLeftToRight()) {
         var2 = new Point(var1.x, var1.y);
      } else {
         var2 = new Point(var1.x + var1.width, var1.y);
      }

      return this.columnAtPoint(var2);
   }

   private int getTrailingRow(Rectangle var1) {
      Point var2;
      if (this.getComponentOrientation().isLeftToRight()) {
         var2 = new Point(var1.x, var1.y + var1.height - 1);
      } else {
         var2 = new Point(var1.x + var1.width, var1.y + var1.height - 1);
      }

      return this.rowAtPoint(var2);
   }

   private int getTrailingCol(Rectangle var1) {
      Point var2;
      if (this.getComponentOrientation().isLeftToRight()) {
         var2 = new Point(var1.x + var1.width - 1, var1.y);
      } else {
         var2 = new Point(var1.x, var1.y);
      }

      return this.columnAtPoint(var2);
   }

   private int leadingEdge(Rectangle var1, int var2) {
      if (var2 == 1) {
         return var1.y;
      } else {
         return this.getComponentOrientation().isLeftToRight() ? var1.x : var1.x + var1.width;
      }
   }

   private int trailingEdge(Rectangle var1, int var2) {
      if (var2 == 1) {
         return var1.y + var1.height;
      } else {
         return this.getComponentOrientation().isLeftToRight() ? var1.x + var1.width : var1.x;
      }
   }

   public boolean getScrollableTracksViewportWidth() {
      return this.autoResizeMode != 0;
   }

   public boolean getScrollableTracksViewportHeight() {
      return this.getFillsViewportHeight() && this.getParent() instanceof JViewport && ((JViewport)this.getParent()).getHeight() > this.getPreferredSize().height;
   }

   public void setFillsViewportHeight(boolean var1) {
      boolean var2 = this.fillsViewportHeight;
      this.fillsViewportHeight = var1;
      this.resizeAndRepaint();
      this.firePropertyChange("fillsViewportHeight", var2, var1);
   }

   public boolean getFillsViewportHeight() {
      return this.fillsViewportHeight;
   }

   protected boolean processKeyBinding(KeyStroke var1, KeyEvent var2, int var3, boolean var4) {
      boolean var5 = super.processKeyBinding(var1, var2, var3, var4);
      if (!var5 && var3 == 1 && this.isFocusOwner() && !Boolean.FALSE.equals((Boolean)this.getClientProperty("JTable.autoStartsEdit"))) {
         Component var6 = this.getEditorComponent();
         if (var6 == null) {
            if (var2 == null || var2.getID() != 401) {
               return false;
            }

            int var7 = var2.getKeyCode();
            if (var7 == 16 || var7 == 17 || var7 == 18) {
               return false;
            }

            int var8 = this.getSelectionModel().getLeadSelectionIndex();
            int var9 = this.getColumnModel().getSelectionModel().getLeadSelectionIndex();
            if (var8 != -1 && var9 != -1 && !this.isEditing() && !this.editCellAt(var8, var9, var2)) {
               return false;
            }

            var6 = this.getEditorComponent();
            if (var6 == null) {
               return false;
            }
         }

         if (var6 instanceof JComponent) {
            var5 = ((JComponent)var6).processKeyBinding(var1, var2, 0, var4);
            if (this.getSurrendersFocusOnKeystroke()) {
               var6.requestFocus();
            }
         }
      }

      return var5;
   }

   private void setLazyValue(Hashtable var1, Class var2, String var3) {
      var1.put(var2, new UIDefaults.ProxyLazyValue(var3));
   }

   private void setLazyRenderer(Class var1, String var2) {
      this.setLazyValue(this.defaultRenderersByColumnClass, var1, var2);
   }

   protected void createDefaultRenderers() {
      this.defaultRenderersByColumnClass = new UIDefaults(8, 0.75F);
      this.setLazyRenderer(Object.class, "javax.swing.table.DefaultTableCellRenderer$UIResource");
      this.setLazyRenderer(Number.class, "javax.swing.JTable$NumberRenderer");
      this.setLazyRenderer(Float.class, "javax.swing.JTable$DoubleRenderer");
      this.setLazyRenderer(Double.class, "javax.swing.JTable$DoubleRenderer");
      this.setLazyRenderer(Date.class, "javax.swing.JTable$DateRenderer");
      this.setLazyRenderer(Icon.class, "javax.swing.JTable$IconRenderer");
      this.setLazyRenderer(ImageIcon.class, "javax.swing.JTable$IconRenderer");
      this.setLazyRenderer(Boolean.class, "javax.swing.JTable$BooleanRenderer");
   }

   private void setLazyEditor(Class var1, String var2) {
      this.setLazyValue(this.defaultEditorsByColumnClass, var1, var2);
   }

   protected void createDefaultEditors() {
      this.defaultEditorsByColumnClass = new UIDefaults(3, 0.75F);
      this.setLazyEditor(Object.class, "javax.swing.JTable$GenericEditor");
      this.setLazyEditor(Number.class, "javax.swing.JTable$NumberEditor");
      this.setLazyEditor(Boolean.class, "javax.swing.JTable$BooleanEditor");
   }

   protected void initializeLocalVars() {
      this.updateSelectionOnSort = true;
      this.setOpaque(true);
      this.createDefaultRenderers();
      this.createDefaultEditors();
      this.setTableHeader(this.createDefaultTableHeader());
      this.setShowGrid(true);
      this.setAutoResizeMode(2);
      this.setRowHeight(16);
      this.isRowHeightSet = false;
      this.setRowMargin(1);
      this.setRowSelectionAllowed(true);
      this.setCellEditor((TableCellEditor)null);
      this.setEditingColumn(-1);
      this.setEditingRow(-1);
      this.setSurrendersFocusOnKeystroke(false);
      this.setPreferredScrollableViewportSize(new Dimension(450, 400));
      ToolTipManager var1 = ToolTipManager.sharedInstance();
      var1.registerComponent(this);
      this.setAutoscrolls(true);
   }

   protected TableModel createDefaultDataModel() {
      return new DefaultTableModel();
   }

   protected TableColumnModel createDefaultColumnModel() {
      return new DefaultTableColumnModel();
   }

   protected ListSelectionModel createDefaultSelectionModel() {
      return new DefaultListSelectionModel();
   }

   protected JTableHeader createDefaultTableHeader() {
      return new JTableHeader(this.columnModel);
   }

   protected void resizeAndRepaint() {
      this.revalidate();
      this.repaint();
   }

   public TableCellEditor getCellEditor() {
      return this.cellEditor;
   }

   public void setCellEditor(TableCellEditor var1) {
      TableCellEditor var2 = this.cellEditor;
      this.cellEditor = var1;
      this.firePropertyChange("tableCellEditor", var2, var1);
   }

   public void setEditingColumn(int var1) {
      this.editingColumn = var1;
   }

   public void setEditingRow(int var1) {
      this.editingRow = var1;
   }

   public TableCellRenderer getCellRenderer(int var1, int var2) {
      TableColumn var3 = this.getColumnModel().getColumn(var2);
      TableCellRenderer var4 = var3.getCellRenderer();
      if (var4 == null) {
         var4 = this.getDefaultRenderer(this.getColumnClass(var2));
      }

      return var4;
   }

   public Component prepareRenderer(TableCellRenderer var1, int var2, int var3) {
      Object var4 = this.getValueAt(var2, var3);
      boolean var5 = false;
      boolean var6 = false;
      if (!this.isPaintingForPrint()) {
         var5 = this.isCellSelected(var2, var3);
         boolean var7 = this.selectionModel.getLeadSelectionIndex() == var2;
         boolean var8 = this.columnModel.getSelectionModel().getLeadSelectionIndex() == var3;
         var6 = var7 && var8 && this.isFocusOwner();
      }

      return var1.getTableCellRendererComponent(this, var4, var5, var6, var2, var3);
   }

   public TableCellEditor getCellEditor(int var1, int var2) {
      TableColumn var3 = this.getColumnModel().getColumn(var2);
      TableCellEditor var4 = var3.getCellEditor();
      if (var4 == null) {
         var4 = this.getDefaultEditor(this.getColumnClass(var2));
      }

      return var4;
   }

   public Component prepareEditor(TableCellEditor var1, int var2, int var3) {
      Object var4 = this.getValueAt(var2, var3);
      boolean var5 = this.isCellSelected(var2, var3);
      Component var6 = var1.getTableCellEditorComponent(this, var4, var5, var2, var3);
      if (var6 instanceof JComponent) {
         JComponent var7 = (JComponent)var6;
         if (var7.getNextFocusableComponent() == null) {
            var7.setNextFocusableComponent(this);
         }
      }

      return var6;
   }

   public void removeEditor() {
      KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener("permanentFocusOwner", this.editorRemover);
      this.editorRemover = null;
      TableCellEditor var1 = this.getCellEditor();
      if (var1 != null) {
         var1.removeCellEditorListener(this);
         if (this.editorComp != null) {
            Component var2 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
            boolean var3 = var2 != null ? SwingUtilities.isDescendingFrom(var2, this) : false;
            this.remove(this.editorComp);
            if (var3) {
               this.requestFocusInWindow();
            }
         }

         Rectangle var4 = this.getCellRect(this.editingRow, this.editingColumn, false);
         this.setCellEditor((TableCellEditor)null);
         this.setEditingColumn(-1);
         this.setEditingRow(-1);
         this.editorComp = null;
         this.repaint(var4);
      }

   }

   private void writeObject(ObjectOutputStream var1) throws IOException {
      var1.defaultWriteObject();
      if (this.getUIClassID().equals("TableUI")) {
         byte var2 = JComponent.getWriteObjCounter(this);
         --var2;
         JComponent.setWriteObjCounter(this, var2);
         if (var2 == 0 && this.ui != null) {
            this.ui.installUI(this);
         }
      }

   }

   private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      var1.defaultReadObject();
      if (this.ui != null && this.getUIClassID().equals("TableUI")) {
         this.ui.installUI(this);
      }

      this.createDefaultRenderers();
      this.createDefaultEditors();
      if (this.getToolTipText() == null) {
         ToolTipManager.sharedInstance().registerComponent(this);
      }

   }

   void compWriteObjectNotify() {
      super.compWriteObjectNotify();
      if (this.getToolTipText() == null) {
         ToolTipManager.sharedInstance().unregisterComponent(this);
      }

   }

   protected String paramString() {
      String var1 = this.gridColor != null ? this.gridColor.toString() : "";
      String var2 = this.showHorizontalLines ? "true" : "false";
      String var3 = this.showVerticalLines ? "true" : "false";
      String var4;
      if (this.autoResizeMode == 0) {
         var4 = "AUTO_RESIZE_OFF";
      } else if (this.autoResizeMode == 1) {
         var4 = "AUTO_RESIZE_NEXT_COLUMN";
      } else if (this.autoResizeMode == 2) {
         var4 = "AUTO_RESIZE_SUBSEQUENT_COLUMNS";
      } else if (this.autoResizeMode == 3) {
         var4 = "AUTO_RESIZE_LAST_COLUMN";
      } else if (this.autoResizeMode == 4) {
         var4 = "AUTO_RESIZE_ALL_COLUMNS";
      } else {
         var4 = "";
      }

      String var5 = this.autoCreateColumnsFromModel ? "true" : "false";
      String var6 = this.preferredViewportSize != null ? this.preferredViewportSize.toString() : "";
      String var7 = this.rowSelectionAllowed ? "true" : "false";
      String var8 = this.cellSelectionEnabled ? "true" : "false";
      String var9 = this.selectionForeground != null ? this.selectionForeground.toString() : "";
      String var10 = this.selectionBackground != null ? this.selectionBackground.toString() : "";
      return super.paramString() + ",autoCreateColumnsFromModel=" + var5 + ",autoResizeMode=" + var4 + ",cellSelectionEnabled=" + var8 + ",editingColumn=" + this.editingColumn + ",editingRow=" + this.editingRow + ",gridColor=" + var1 + ",preferredViewportSize=" + var6 + ",rowHeight=" + this.rowHeight + ",rowMargin=" + this.rowMargin + ",rowSelectionAllowed=" + var7 + ",selectionBackground=" + var10 + ",selectionForeground=" + var9 + ",showHorizontalLines=" + var2 + ",showVerticalLines=" + var3;
   }

   public boolean print() throws PrinterException {
      return this.print(javax.swing.JTable.PrintMode.FIT_WIDTH);
   }

   public boolean print(PrintMode var1) throws PrinterException {
      return this.print(var1, (MessageFormat)null, (MessageFormat)null);
   }

   public boolean print(PrintMode var1, MessageFormat var2, MessageFormat var3) throws PrinterException {
      boolean var4 = !GraphicsEnvironment.isHeadless();
      return this.print(var1, var2, var3, var4, (PrintRequestAttributeSet)null, var4);
   }

   public boolean print(PrintMode var1, MessageFormat var2, MessageFormat var3, boolean var4, PrintRequestAttributeSet var5, boolean var6) throws PrinterException, HeadlessException {
      return this.print(var1, var2, var3, var4, var5, var6, (PrintService)null);
   }

   public boolean print(PrintMode var1, MessageFormat var2, MessageFormat var3, boolean var4, PrintRequestAttributeSet var5, boolean var6, PrintService var7) throws PrinterException, HeadlessException {
      boolean var8 = GraphicsEnvironment.isHeadless();
      if (var8) {
         if (var4) {
            throw new HeadlessException("Can't show print dialog.");
         }

         if (var6) {
            throw new HeadlessException("Can't run interactively.");
         }
      }

      PrinterJob var9 = PrinterJob.getPrinterJob();
      if (this.isEditing() && !this.getCellEditor().stopCellEditing()) {
         this.getCellEditor().cancelCellEditing();
      }

      if (var5 == null) {
         var5 = new HashPrintRequestAttributeSet();
      }

      Printable var11 = this.getPrintable(var1, var2, var3);
      PrintingStatus var10;
      if (var6) {
         ThreadSafePrintable var20 = new ThreadSafePrintable(this, var11);
         var10 = PrintingStatus.createPrintingStatus(this, var9);
         var11 = var10.createNotificationPrintable(var20);
      } else {
         var10 = null;
      }

      var9.setPrintable(var11);
      if (var7 != null) {
         var9.setPrintService(var7);
      }

      if (var4 && !var9.printDialog((PrintRequestAttributeSet)var5)) {
         return false;
      } else if (!var6) {
         var9.print((PrintRequestAttributeSet)var5);
         return true;
      } else {
         this.printError = null;
         Object var12 = new Object();
         6 var14 = new 6(this, var9, (PrintRequestAttributeSet)var5, var12, var10);
         Thread var15 = new Thread(var14);
         var15.start();
         var10.showModal(true);
         Throwable var16;
         synchronized(var12) {
            var16 = this.printError;
            this.printError = null;
         }

         if (var16 != null) {
            if (var16 instanceof PrinterAbortException) {
               return false;
            } else if (var16 instanceof PrinterException) {
               throw (PrinterException)var16;
            } else if (var16 instanceof RuntimeException) {
               throw (RuntimeException)var16;
            } else if (var16 instanceof Error) {
               throw (Error)var16;
            } else {
               throw new AssertionError(var16);
            }
         } else {
            return true;
         }
      }
   }

   public Printable getPrintable(PrintMode var1, MessageFormat var2, MessageFormat var3) {
      return new TablePrintable(this, var1, var2, var3);
   }

   public AccessibleContext getAccessibleContext() {
      if (this.accessibleContext == null) {
         this.accessibleContext = new AccessibleJTable(this);
      }

      return this.accessibleContext;
   }

   // $FF: synthetic method
   static int access$200(JTable var0, RowSorterEvent var1, int var2) {
      return var0.convertRowIndexToModel(var1, var2);
   }

   // $FF: synthetic method
   static int[] access$300(JTable var0, RowSorterEvent var1) {
      return var0.convertSelectionToModel(var1);
   }

   // $FF: synthetic method
   static SizeSequence access$402(JTable var0, SizeSequence var1) {
      return var0.rowModel = var1;
   }

   // $FF: synthetic method
   static SizeSequence access$400(JTable var0) {
      return var0.rowModel;
   }

   // $FF: synthetic method
   static void access$500(JTable var0, int[] var1, int var2, ModelChange var3) {
      var0.restoreSortingSelection(var1, var2, var3);
   }

   // $FF: synthetic method
   static Throwable access$602(JTable var0, Throwable var1) {
      return var0.printError = var1;
   }
}